package handlers

import (
	"net/http"
	"strconv"

	"backend-api/internal/middleware"
	"backend-api/internal/services"

	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
)

// AdminHandler 管理员处理器
type AdminHandler struct {
	adminService *services.AdminService
}

// NewAdminHandler 创建管理员处理器实例
func NewAdminHandler() *AdminHandler {
	return &AdminHandler{
		adminService: services.NewAdminService(),
	}
}

// Login 管理员登录
// @Summary 管理员登录
// @Description 后台管理员登录接口
// @Tags 后台管理
// @Accept json
// @Produce json
// @Param request body services.AdminLoginRequest true "登录信息"
// @Success 200 {object} map[string]interface{} "登录成功"
// @Failure 401 {object} map[string]interface{} "登录失败"
// @Router /admin/login [post]
func (h *AdminHandler) Login(c *gin.Context) {
	var req services.AdminLoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logrus.WithError(err).Error("管理员登录参数绑定失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "参数错误: " + err.Error(),
			"data":    nil,
		})
		return
	}

	response, err := h.adminService.Login(&req)
	if err != nil {
		logrus.WithError(err).Error("管理员登录失败")
		c.JSON(http.StatusUnauthorized, gin.H{
			"code":    401,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	logrus.WithField("admin_id", response.Admin.ID).Info("管理员登录成功")
	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "登录成功",
		"data":    response,
	})
}

// GetProfile 获取管理员信息
// @Summary 获取管理员信息
// @Description 获取当前登录管理员的个人信息
// @Tags 后台管理
// @Accept json
// @Produce json
// @Security AdminAuth
// @Success 200 {object} map[string]interface{} "获取成功"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器错误"
// @Router /admin/profile [get]
func (h *AdminHandler) GetProfile(c *gin.Context) {
	adminID, exists := middleware.GetCurrentAdminID(c)
	if !exists {
		c.JSON(http.StatusUnauthorized, gin.H{
			"code":    401,
			"message": "未找到管理员信息",
			"data":    nil,
		})
		return
	}

	admin, err := h.adminService.GetProfile(adminID)
	if err != nil {
		logrus.WithError(err).Error("获取管理员信息失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "获取成功",
		"data":    admin,
	})
}

// Logout 管理员退出登录
// @Summary 管理员退出登录
// @Description 后台管理员退出登录接口
// @Tags 后台管理
// @Accept json
// @Produce json
// @Security AdminAuth
// @Success 200 {object} map[string]interface{} "退出成功"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Router /admin/logout [post]
func (h *AdminHandler) Logout(c *gin.Context) {
	adminID, exists := middleware.GetCurrentAdminID(c)
	if !exists {
		c.JSON(http.StatusUnauthorized, gin.H{
			"code":    401,
			"message": "未找到管理员信息",
			"data":    nil,
		})
		return
	}

	// 这里可以实现JWT黑名单机制，将令牌加入Redis黑名单
	// 目前简单返回成功响应
	logrus.WithField("admin_id", adminID).Info("管理员退出登录")
	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "退出登录成功",
		"data":    nil,
	})
}

// GetUserList 获取用户列表
// @Summary 获取用户列表
// @Description 管理员获取用户列表（支持分页和搜索）
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security AdminAuth
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(10)
// @Param keyword query string false "搜索关键词"
// @Param status query int false "用户状态"
// @Success 200 {object} map[string]interface{} "获取成功"
// @Failure 400 {object} map[string]interface{} "参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器错误"
// @Router /admin/users [get]
func (h *AdminHandler) GetUserList(c *gin.Context) {
	var req services.UserListRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		logrus.WithError(err).Error("获取用户列表参数绑定失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "参数错误: " + err.Error(),
			"data":    nil,
		})
		return
	}

	response, err := h.adminService.GetUserList(&req)
	if err != nil {
		logrus.WithError(err).Error("获取用户列表失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "获取成功",
		"data":    response,
	})
}

// GetUserByID 获取用户详情
// @Summary 获取用户详情
// @Description 管理员根据用户ID获取用户详细信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security AdminAuth
// @Param id path int true "用户ID"
// @Success 200 {object} map[string]interface{} "获取成功"
// @Failure 400 {object} map[string]interface{} "参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器错误"
// @Router /admin/users/{id} [get]
func (h *AdminHandler) GetUserByID(c *gin.Context) {
	userIDStr := c.Param("id")
	userID, err := strconv.ParseUint(userIDStr, 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "用户ID格式错误",
			"data":    nil,
		})
		return
	}

	user, err := h.adminService.GetUserByID(uint(userID))
	if err != nil {
		logrus.WithError(err).Error("获取用户详情失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "获取成功",
		"data":    user,
	})
}

// UpdateUserStatus 更新用户状态
// @Summary 更新用户状态
// @Description 管理员更新用户状态（启用/禁用）
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security AdminAuth
// @Param id path int true "用户ID"
// @Param request body services.UpdateUserStatusRequest true "状态信息"
// @Success 200 {object} map[string]interface{} "更新成功"
// @Failure 400 {object} map[string]interface{} "参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器错误"
// @Router /admin/users/{id}/status [put]
func (h *AdminHandler) UpdateUserStatus(c *gin.Context) {
	userIDStr := c.Param("id")
	userID, err := strconv.ParseUint(userIDStr, 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "用户ID格式错误",
			"data":    nil,
		})
		return
	}

	var req services.UpdateUserStatusRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logrus.WithError(err).Error("更新用户状态参数绑定失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "参数错误: " + err.Error(),
			"data":    nil,
		})
		return
	}

	if err := h.adminService.UpdateUserStatus(uint(userID), req.Status); err != nil {
		logrus.WithError(err).Error("更新用户状态失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	adminID, _ := middleware.GetCurrentAdminID(c)
	logrus.WithFields(logrus.Fields{
		"admin_id": adminID,
		"user_id":  userID,
		"status":   req.Status,
	}).Info("管理员更新用户状态")

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "更新成功",
		"data":    nil,
	})
}

// DeleteUser 删除用户
// @Summary 删除用户
// @Description 管理员删除用户账号
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security AdminAuth
// @Param id path int true "用户ID"
// @Success 200 {object} map[string]interface{} "删除成功"
// @Failure 400 {object} map[string]interface{} "参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器错误"
// @Router /admin/users/{id} [delete]
func (h *AdminHandler) DeleteUser(c *gin.Context) {
	userIDStr := c.Param("id")
	userID, err := strconv.ParseUint(userIDStr, 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "用户ID格式错误",
			"data":    nil,
		})
		return
	}

	if err := h.adminService.DeleteUser(uint(userID)); err != nil {
		logrus.WithError(err).Error("删除用户失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	adminID, _ := middleware.GetCurrentAdminID(c)
	logrus.WithFields(logrus.Fields{
		"admin_id": adminID,
		"user_id":  userID,
	}).Info("管理员删除用户")

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "删除成功",
		"data":    nil,
	})
}